_vlie

I'm building an open-source LMS with a content studio for instructors — exams, quizzes, assignments, courses.

Hit a wall with preview.

Instructors don't want a fake preview.

They want to actually take the exam they just built — real timer, real submission, real grading, state persisted across requests — then either publish it or throw everything away.

Looked at three options.

PostgreSQL schema separation is conceptually the cleanest but Django migrations get painful fast.

is_draft flags end up as conditionals in every layer.

Snapshot tables can't run real workflows.

What I actually want is pytest-style DB isolation in production.

Persistable, discardable.

Does this exist? How do systems like this usually handle it?

I'm building an open-source LMS and added plagiarism detection using OpenSearch's more_like_this query plus character n-grams for similarity scoring.

Basically when a student submits an answer, I search for similar answers from other students on the same question. Works decently but feels a bit hacky - just reusing the search engine I already had.

Current setup:

  search = cls.search().filter(
      "nested", path="answers", 
      query={"term": {"answers.question_id": str(question_id)}}
  )
  search = search.query(
      "nested",
      path="answers",
      query={
          "more_like_this": {
              "fields": ["answers.answer"],
              "like": text,
              "min_term_freq": 1,
              "minimum_should_match": "1%",
          }
      },
  )
  
  # get top 10, then re-rank in Python
  def normalize(t):
      return re.sub(r"\s+", "", t.strip())
  
  def char_ngrams(t, n=3):
      return set(t[i:i+n] for i in range(len(t)-n+1))
  
  norm_text = normalize(text)
  text_ngrams = char_ngrams(norm_text)
  
  for hit in response.hits:
      norm_answer = normalize(hit.answer)
      answer_ngrams = char_ngrams(norm_answer)
      
      intersection = len(text_ngrams & answer_ngrams)
      union = len(text_ngrams | answer_ngrams)
      ratio = int((intersection / union) * 100)
      
      if ratio >= 60:
          # flag as similar

Constraints: - Self-hosted only, no external APIs - Few thousand students - Want simple operations, already running OpenSearch anyway

Questions: - Is this approach reasonable or am I missing something obvious? - What do other self-hosted systems use? Checked Moodle docs but their plagiarism plugins mostly call external services - Anyone tried lightweight ML models for this that don't need GPU?

The search engine approach works but curious if there's a better way that fits our constraints.

I’m trying to understand where “vibe coding” realistically stands today.

The project I’m currently working on is getting close to 60k lines of code, with fairly complex business logic. From what I’ve heard, at this scale only a few tools (like Claude’s desktop app) are genuinely helpful, so I haven’t experimented much with other AI coding services.

At the same time, I keep seeing posts about people building 20k lines of code and launching a SaaS in a single 40-hour weekend. That’s made me question whether I’m being overly cautious, or just operating under outdated assumptions.

I already rely on AI quite a bit, and one clear benefit is that I now understand parts of the codebase that I previously wrote without fully grasping. Still, at my current pace, it feels like I’ll need several more months of development, followed by several more months of testing, before this can become a real production service. And that testing doesn’t feel optional.

Meanwhile, products that are described as being “vibe coded” don’t seem to be getting particularly negative evaluations.

So I’m wondering how people here think about this now. Is “you don’t really understand the code, so it’ll hurt you later” still a meaningful criticism? Or are we reaching a point where the default approach to building software itself needs to change?

I’d especially appreciate perspectives from people working on larger or more complex systems.